﻿using System;
//using System.Collections.Generic;
//using System.Linq;
using FireStarter.Base;
using Firestarter.DB.Schema.BO;
using FireStarterModeller.BO;
using Habanero.Base;
//using Habanero.BO.ClassDefinition;
using NUnit.Framework;

namespace FireStarterModeller.Test.Logic
{

    [TestFixture]
    public class TestCodeTemplateLibraryFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardCodeTemplateLibrary();
        }

        protected override string GetFstartFileName()
        {
            return "standardCodeTemplateLibrary.fstart";
        }

        private static CodeTemplateLibrary CreateStandardCodeTemplateLibrary()
        {
            CodeTemplateLibrary codeTemplateLibrary = GetStandardCodeTemplateLibrary();
            codeTemplateLibrary.Save();
            return codeTemplateLibrary;
        }

        private static CodeTemplateLibrary GetStandardCodeTemplateLibrary()
        {
            return new CodeTemplateLibrary { CodeTemplateLibraryName = "StandardName" };
        }
    }

    [TestFixture]
    public class TestDatabaseConnectionInfoFsStartLoading : TestFsStartLoadingBase
    {
 
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDatabaseConnection();
        }

        protected override string GetFstartFileName()
        {
            return "standardDatabaseConnectionInfo.fstart";
        }

        private static DatabaseConnectionInfo CreateStandardDatabaseConnection()
        {
            DatabaseConnectionInfo databaseConnection = GetStandardDatabaseConnection();
            databaseConnection.Save();
            return databaseConnection;
        }

        private static DatabaseConnectionInfo GetStandardDatabaseConnection()
        {
            return new DatabaseConnectionInfo
                   {
                       Vendor = "SqlServer",
                       Server = "StandardServer",
                       Port = "StandardPort",
                       Database = "StandardDatabase",
                       UserName = "StandardUserName",
                       Password = "StandardPassword"
                   };
        }
    }

    [TestFixture]
    public class TestDMSolutionFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMSolution();
        }
        protected override string GetFstartFileName()
        {
            return "standardDMSolution.fstart";
        }

        private static DMSolution CreateStandardDMSolution()
        {
            DMSolution dmSolution = GetStandardDMSolution();
            dmSolution.Save();
            return dmSolution;
        }

        private static DMSolution GetStandardDMSolution()
        {
            return new DMSolution
                   {
                       //SolutionID = Guid.NewGuid(),
                       SolutionName = "StdSolutionName",
                       DefaultAssemblyID = Guid.NewGuid(),
                       HabaneroDllPath = @"C:\habanero path",
                       TableNamePrefix = "tbl",
                       TableNameSuffix = "tbl",
                       PascalCase = true,
                       SolutionDirectory = @"C:\",
                       UIProjectName = "stdUIProjectName",
                       BOProjectName = "stdBOProjectName",
                       LogicProjectName = "stdLogicProjectName",
                       BaseProjectName = "stdBaseProjectName",
                       Generated = false,
                       BOTestProjectName = "stdBOTestProjectName",
                       UITestProjectName = "stdUITestProjectName",
                       SolutionDescription = "stdSolution description",
                       BaseTestProjectName = "stdBaseTestProjectName"
                   };
        }
    }


    [TestFixture]
    public class TestDMPropertyTypeFsStartLoading : TestFsStartLoadingBase
    {
   
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMPropertyType();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMPropertyType.fstart";
        }

        private static DMPropertyType CreateStandardDMPropertyType()
        {
            DMPropertyType dmPropertyType = GetStandardDMPropertyType();
            dmPropertyType.Save();
            return dmPropertyType;
        }

        private static DMPropertyType GetStandardDMPropertyType()
        {
            return new DMPropertyType("stdAssemblyName", "stdPropertyName");
        }
    }

    [TestFixture]
    public class TestDMAssemblyFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMAssembly();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMAssembly.fstart";
        }

        private static DMAssembly CreateStandardDMAssembly()
        {

            DMAssembly dmAssembly = GetStandardDMAssembly();
            dmAssembly.Save();
            return dmAssembly;
        }

        private static DMAssembly GetStandardDMAssembly()
        {
            return new DMAssembly
                   {
                      // AssemblyID = Guid.NewGuid(),
                       Name = "StdSolutionName.BO",
                       SolutionID = Guid.NewGuid(),
                       Description = "stdAssembly description",
                   };
        }
    }

    [TestFixture]
    public class TestUIControlMapperTypeFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIControlMapperType();
        }

        protected override string GetFstartFileName()
        {
            return "standardUIControlMapperType.fstart";
        }

        private static UIControlMapperType CreateStandardUIControlMapperType()
        {
            UIControlMapperType uiControlMapperType = GetStandardUIControlMapperType();
            uiControlMapperType.Save();
            return uiControlMapperType;
        }

        private static UIControlMapperType GetStandardUIControlMapperType()
        {
            return new UIControlMapperType
                   {
                      // UIControlMapperTypeID = Guid.NewGuid(),
                       AssemblyName = "stdAssemblyName",
                       TypeName = "stdMapperType",
                       SolutionID = Guid.NewGuid()
                   };
        }
    }

    [TestFixture]
    public class TestUIControlTypeFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIControlType();
        }

        protected override string GetFstartFileName()
        {
            return "standardUIControlType.fstart";
        }

        private static UIControlType CreateStandardUIControlType()
        {
            UIControlType uiControlType = GetStandardUIControlType();
            uiControlType.Save();
            return uiControlType;
        }

        private static UIControlType GetStandardUIControlType()
        {
            return new UIControlType
                   {
                       AssemblyName = "stdAssemblyName",
                       TypeName = "stdTypeName",
                       //UIControlTypeID = Guid.NewGuid(),
                       SolutionID = Guid.NewGuid()
                   };
        }
    }

    [TestFixture]
    public class TestUITypeDefinitionFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUITypeDefinition();
        }

        protected override string GetFstartFileName()
        {
            return "standardUITypeDefinition.fstart";
        }

        private static UITypeDefinition CreateStandardUITypeDefinition()
        {
            UITypeDefinition uiTypeDefinition = GetStandardUITypeDefinition();
            uiTypeDefinition.Save();
            return uiTypeDefinition;
        }

        private static UITypeDefinition GetStandardUITypeDefinition()
        {
            return new UITypeDefinition
                   {
                       //UITypeDefinitionID = Guid.NewGuid(),
                       AssemblyName = "stdAssemblyName",
                       TypeName = "stdTypeName",
                       SolutionID = Guid.NewGuid(),
                       TypeDescriminator = "stdTypeDescriminator"
                   };
        }
    }


    [TestFixture]
    public class TestUIGridColumnControlTypeFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIGridColumnControlType();
        }

        protected override string GetFstartFileName()
        {
            return "standardUIGridColumnControlType.fstart"; 
        }

        private static UIGridColumnControlType CreateStandardUIGridColumnControlType()
        {
            UIGridColumnControlType uiGridColumnControlType = GetStandardUIGridColumnControlType();
            uiGridColumnControlType.Save();
            return uiGridColumnControlType;
        }

        private static UIGridColumnControlType GetStandardUIGridColumnControlType()
        {
            return new UIGridColumnControlType
                   {
                       //UIGridColumnControlTypeID = Guid.NewGuid(),
                       AssemblyName = "stdAssemblyName",
                       TypeName = "stdTypeName",
                       SolutionID = Guid.NewGuid()
                   };
        }
    }

    [TestFixture]
    public class TestDBTableFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDBTable();
        }

        protected override string GetFstartFileName()
        {
            return "standardDBTable.fstart";
        }

        private static DBTable CreateStandardDBTable()
        {
            DBTable dbTable = GetStandardDBTable();
            dbTable.Save();
            return dbTable;
        }

        private static DBTable GetStandardDBTable()
        {
            return new DBTable
                   {
                       DateCreated = new DateTime(2010, 10, 01),
                       Owner = "stdOwner",
                       TableName = "stdTableName",
                       SchemaName = "stdSchemaName",
                       //TableID = Guid.NewGuid(),
                       DatabaseID = Guid.NewGuid(),
                       TableType = "stdTableType",
                       TableComment = "stdTableComment",
                       CreateTime = new DateTime(2010, 10, 01),
                       UpdateTime = new DateTime(2010, 10, 01),
                       PendingChangeType = ChangeType.None,
                       Approved = true

                   };
        }
    }

    [TestFixture]
    public class TestDBColumnFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDBColumn();
        }

        protected override string GetFstartFileName()
        {
            return "standardDBColumn.fstart";
        }

        private static DBColumn CreateStandardDBColumn()
        {
            DBColumn dbColumn = GetStandardDBColumn();

            dbColumn.Save();
            return dbColumn;
        }

        private static DBColumn GetStandardDBColumn()
        {
            return new DBColumn
                   {
                      // ColumnID = Guid.NewGuid(),
                       ColumnName = "stdColumnName",
                       DataType = "stdDataType",
                       DataLength = new int(),
                       Nullable = false,
                       DefaultValue = "stdDefaultValue",
                       TableID = Guid.NewGuid(),
                       IsAutoIncrementing = false,
                       Comment = "stdColumnComment",
                       OrdinalPosition = new int(),
                       PendingChangeType = ChangeType.None,
                       Approved = true
                   };
        }
    }

    [TestFixture]
    public class TestDBForeignKeyColumnFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDBForeignKeyColumn();
        }

        protected override string GetFstartFileName()
        {
            return "standardDBForeignKeyColumn.fstart";
        }

        private static DBForeignKeyColumn CreateStandardDBForeignKeyColumn()
        {
            DBForeignKeyColumn dbForeignKeyColumn = GetStandardDBForeignKeyColumn();

            dbForeignKeyColumn.Save();
            return dbForeignKeyColumn;
        }

        private static DBForeignKeyColumn GetStandardDBForeignKeyColumn()
        {
            return new DBForeignKeyColumn
                   {
                       //ForeignKeyColumnID = Guid.NewGuid(),
                       ForeignKeyID = Guid.NewGuid(),
                       ParentColumnID = Guid.NewGuid(),
                       RelatedColumnID = Guid.NewGuid(),
                       PendingChangeType = ChangeType.None,
                       Approved = true
                   };
        }
    }
    
    [TestFixture]
    public class TestDBForeignKeyFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDBForeignKey();
        }

        protected override string GetFstartFileName()
        {
            return "standardDBForeignKey.fstart";
        }

        private static DBForeignKey CreateStandardDBForeignKey()
        {
            DBForeignKey dbForeignKey = GetStandardDBForeignKey();

            dbForeignKey.Save();
            return dbForeignKey;
        }

        private static DBForeignKey GetStandardDBForeignKey()
        {
            return new DBForeignKey
                   {
                      // ForeignKeyID = Guid.NewGuid(),
                       ParentTableID = Guid.NewGuid(),
                       RelatedTableID = Guid.NewGuid(),
                       ForeignKeyName = "stdDBForeignKeyName",
                       PendingChangeType = ChangeType.None,
                       Approved = true
                   };
        }
    }
   
    [TestFixture]
    public class TestDBPrimaryKeyColumnFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDBPrimaryKeyColumn();
        }

        protected override string GetFstartFileName()
        {
            return "standardDBPrimaryKeyColumn.fstart";
        }

        private static DBPrimaryKeyColumn CreateStandardDBPrimaryKeyColumn()
        {
            DBPrimaryKeyColumn dbPrimaryKeyColumn = GetStandardDBPrimaryKeyColumn();
            dbPrimaryKeyColumn.Save();
            return dbPrimaryKeyColumn;
        }

        private static DBPrimaryKeyColumn GetStandardDBPrimaryKeyColumn()
        {
            return new DBPrimaryKeyColumn
                   {
                       //PrimaryKeyID = Guid.NewGuid(),
                       ColumnID = Guid.NewGuid(),
                       PendingChangeType = ChangeType.None,
                       Approved =true
             
                   };
        }
    }
   
    [TestFixture]
    public class TestDBPrimaryKeyFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDBPrimaryKey();
        }

        protected override string GetFstartFileName()
        {
            return "standardDBPrimaryKey.fstart";
        }

        private static DBPrimaryKey CreateStandardDBPrimaryKey()
        {
            DBPrimaryKey dbPrimaryKey = GetStandardDBPrimaryKey();
            dbPrimaryKey.Save();
            return dbPrimaryKey;
        }

        private static DBPrimaryKey GetStandardDBPrimaryKey()
        {
            return new DBPrimaryKey
                   {
                      // PrimaryKeyID  = Guid.NewGuid(),
                       TableID = Guid.NewGuid(),
                       PendingChangeType = ChangeType.None,
                       Approved = true

                   };
        }
    }
   
    [TestFixture]
    public class TestDBKeyColumnFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDBKeyColumn();
        }

        protected override string GetFstartFileName()
        {
            return "standardDBKeyColumn.fstart";
        }

        private static DBKeyColumn CreateStandardDBKeyColumn()
        {
            DBKeyColumn dbKeyColumn = GetStandardDBKeyColumn();
            dbKeyColumn.Save();
            return dbKeyColumn;
        }

        private static DBKeyColumn GetStandardDBKeyColumn()
        {
            return new DBKeyColumn
                   {   
                      //ColumnID = Guid.NewGuid(),
                       KeyID = Guid.NewGuid(),
                       PendingChangeType = ChangeType.None,
                       Approved = true

                   };
        }
    }
    
    [TestFixture]
    public class TestDBKeyFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDBKey();
        }

        protected override string GetFstartFileName()
        {
            return "standardDBKey.fstart";
        }

        private static DBKey CreateStandardDBKey()
        {
            DBKey dbKey = GetStandardDBKey();
            dbKey.Save();
            return dbKey;
        }

        private static DBKey GetStandardDBKey()
        {
            return new DBKey
                   {
                       //KeyID = Guid.NewGuid(),
                       KeyName = "stdKeyName",
                       TableID = Guid.NewGuid(),
                       PendingChangeType = ChangeType.None,
                       Approved = true

                   };
        }
    }

    [TestFixture]
    public class TestDBViewFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDBView();
        }

        protected override string GetFstartFileName()
        {
            return "standardDBView.fstart";
        }

        private static DBView CreateStandardDBView()
        {
            DBView dbView = GetStandardDBView();
            dbView.Save();
            return dbView;
        }

        private static DBView GetStandardDBView()
        {
            return new DBView
                   {   Owner = "stdDBViewOwner",
                       TableName = "stdTableName",
                       SchemaName = "stdSchemaName",
                       //ViewID = Guid.NewGuid(),
                       DatabaseID = Guid.NewGuid(),
                       TableType = "stdTableType",
                       TableComment = "stdTableComment",
                       CreateTime = new DateTime(2010, 10, 19),
                       UpdateTime = new DateTime(2010, 10, 19),
                       PendingChangeType = ChangeType.None,
                       Approved = true
                   };
        }
    }
    
    [TestFixture]
    public class TestDBViewColumnFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDBViewColumn();
        }

        protected override string GetFstartFileName()
        {
            return "standardDBViewColumn.fstart";
        }

        private static DBViewColumn CreateStandardDBViewColumn()
        {
            DBViewColumn dbViewColumn = GetStandardDBViewColumn();
            dbViewColumn.Save();
            return dbViewColumn;
        }

        private static DBViewColumn GetStandardDBViewColumn()
        {
            return new DBViewColumn
                   {
                       ColumnID = Guid.NewGuid(),
                       ColumnName = "stdColumnName",
                       DataType = "stdDataType",
                       DataLength = 50,
                       Nullable = true,
                       DefaultValue = "stdDefaultValue",
                       IsAutoIncrementing = false,
                       Comment = "stdViewComment", 
                       OrdinalPosition = 1,
                       PendingChangeType = ChangeType.None,
                       Approved = true
                   };
        }
    }
    
    [TestFixture]
    public class TestDMObjectIdentityFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMObjectIdentity();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMObjectIdentity.fstart";
        }

        private static DMObjectIdentity CreateStandardDMObjectIdentity()
        {
            DMObjectIdentity dmObjectIdentity = GetStandardDMObjectIdentity();
            dmObjectIdentity.Save();
            return dmObjectIdentity;
        }
       
        private static DMObjectIdentity GetStandardDMObjectIdentity()
        {
            return new DMObjectIdentity
                   {
                      // ObjectIdentityID = Guid.NewGuid(),
                       ClassID = Guid.NewGuid(),
                       IsObjectID = false,
                       Generated = false,
                       MappedPrimaryKeyID = Guid.NewGuid()
                   };
        }
    }
  
    [TestFixture]
    public class TestDMPropRuleFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMPropRule();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMPropRule.fstart";
        }

        private static DMPropRule CreateStandardDMPropRule()
        {
            DMPropRule dmPropRule = GetStandardDMPropRule();
            dmPropRule.Save();
            return dmPropRule;
        }

        private static DMPropRule GetStandardDMPropRule()
        {
            return new DMPropRule
                   {
                      // PropRuleID = Guid.NewGuid(),
                       PropRuleName = "stdPropRuleName",
                       Message = "stdPropRuleMessage",
                       Class = "stdClass",
                       Assembly = "stdAssembly",
                       Generated = false
                   };
        }
    }
   
    [TestFixture]
    public class TestDMPropRuleParameterFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMPropRuleParameter();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMPropRuleParameter.fstart";
        }

        private static DMPropRuleParameter CreateStandardDMPropRuleParameter()
        {
            DMPropRuleParameter dmPropRuleParameter = GetStandardDMPropRuleParameter();
            dmPropRuleParameter.Save();
            return dmPropRuleParameter;
        }

        private static DMPropRuleParameter GetStandardDMPropRuleParameter()
        {
            return new DMPropRuleParameter
                   {
                       //PropRuleParameterID = Guid.NewGuid(),
                       RuleID = Guid.NewGuid(),
                       KeyName = "std",
                       Value = "stdPropRuleParameterValue",
                       PropRuleID = Guid.NewGuid(),
                       Generated = false,
                       OrdinalPosition = 1
                   };
        }
    }

    [TestFixture]
    public class TestDMRelationshipPropertyFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMRelationshipProperty();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMRelationshipProperty.fstart";
        }

        private static DMRelationshipProperty CreateStandardDMRelationshipProperty()
        {
            DMRelationshipProperty dmRelationshipProperty = GetStandardDMRelationshipProperty();
            dmRelationshipProperty.Save();
            return dmRelationshipProperty;
        }

        private static DMRelationshipProperty GetStandardDMRelationshipProperty()
        {
            return new DMRelationshipProperty(null)
                   {
                       //RelationshipPropertyID = Guid.NewGuid(),
                       RelationshipID = Guid.NewGuid(),
                       PropertyID = Guid.NewGuid(),
                       ReverseRelationshipProperty = null,
                       Generated = false
                   };
        }
    }

    [TestFixture]
    public class TestDMRelationshipFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMRelationship();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMRelationship.fstart";
        }

        private static DMRelationship CreateStandardDMRelationship()
        {
            DMRelationship dmRelationship = GetStandardDMRelationship();
            dmRelationship.Save();
            return dmRelationship;
        }

        private static DMRelationship GetStandardDMRelationship()
        {
            return new DMRelationship(null)
                   {
                       //RelationshipID = Guid.NewGuid(),
                       ClassID = Guid.NewGuid(),
                       ReverseRelationshipID = Guid.NewGuid(),
                       RelationshipName = "stdRelationshipName",
                       Cardinality = Cardinality.Multiple,
                       RelationshipType = RelationshipType.Association,
                       DeleteAction = DeleteParentAction.Prevent,
                       InsertParentAction = InsertParentAction.DoNothing,
                       Timeout = new int(),
                       MappedForeignKeyID = Guid.NewGuid(),
                       Generated = false,
                       DMSortOrderID = Guid.NewGuid(),
                       GenerateCode = true

                   };
        }
    }
   
    [TestFixture]
    public class TestDMUniqueConstraintPropertyFsStartLoading : TestFsStartLoadingBase
    {
 
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMUniqueConstraintProperty();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMUniqueConstraintProperty.fstart";
        }

        private static DMUniqueConstraintProperty CreateStandardDMUniqueConstraintProperty()
        {
            DMUniqueConstraintProperty dmUniqueConstraintProperty = GetStandardDMUniqueConstraintProperty();
            dmUniqueConstraintProperty.Save();
            return dmUniqueConstraintProperty;
        }

        private static DMUniqueConstraintProperty GetStandardDMUniqueConstraintProperty()
        {
            return new DMUniqueConstraintProperty
                   {
                       //UniqueConstraintPropertyID = Guid.NewGuid(),
                       PropertyID = Guid.NewGuid(),
                       UniqueConstraintID = Guid.NewGuid(),
                   };
        }
    }

    [TestFixture]
    public class TestDMUniqueConstraintFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMUniqueConstraint();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMUniqueConstraint.fstart";
        }

        private static DMUniqueConstraint CreateStandardDMUniqueConstraint()
        {
            DMUniqueConstraint dmUniqueConstraint = GetStandardDMUniqueConstraint();
            dmUniqueConstraint.Save();
            return dmUniqueConstraint;
        }

        private static DMUniqueConstraint GetStandardDMUniqueConstraint()
        {
            return new DMUniqueConstraint
                   {
                       //UniqueConstraintID = Guid.NewGuid(),
                       ClassID  = Guid.NewGuid(),
                       Message = "stdDMUniqueConstraintMessage",
                       IgnoreIfNull = true,
                       UniqueConstraintName = "stdUniqueConstraintName",
                       Generated = false,
                       MappedAlternateKeyID = Guid.NewGuid()
                   };
        }
    }

    [TestFixture]
    public class TestDMLookupListSimpleFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMLookupListSimple();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMLookupListSimple.fstart";
        }

        private static DMLookupListSimple CreateStandardDMLookupListSimple()
        {
            DMLookupListSimple dmLookupListSimple = GetStandardDMLookupListSimple();
            dmLookupListSimple.Save();
            return dmLookupListSimple;
        }

        private static DMLookupListSimple GetStandardDMLookupListSimple()
        {
            return new DMLookupListSimple
                   {
                       SimpleLookupListID = Guid.NewGuid(),
                       LookupListID = Guid.NewGuid(),
                       Generated = true,
                   };
        }
    }

    [TestFixture]
    public class TestDMListItemFsStartLoading : TestFsStartLoadingBase
    {


        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMListItem();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMListItem.fstart";
        }

        private static DMListItem CreateStandardDMListItem()
        {
            DMListItem dmListItem =  GetStandardDMListItem();
            dmListItem.Save();
            return dmListItem;
        }
             
        private static DMListItem GetStandardDMListItem()
        {
            return new DMListItem
            {
                //ListItemID = Guid.NewGuid(),
                Value = "stdDMListItemValue",
                Display = "stdDMListItemDisplay",
                Generated = false,
                SimpleLookupListID = Guid.NewGuid(),
                Description = "stdDMListItemDescription",
                OrdinalPosition = 1
            };
        }
    }


    [TestFixture]
    public class TestDMLookupListBusinessObjectFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMLookupListBusinessObject();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMLookupListBusinessObject.fstart";
        }

        private static DMLookupListBusinessObject CreateStandardDMLookupListBusinessObject()
        {
            DMLookupListBusinessObject dmLookupListBusinessObject = GetStandardDMLookupListBusinessObject();
            dmLookupListBusinessObject.Save();
            return dmLookupListBusinessObject;
        }

        private static DMLookupListBusinessObject GetStandardDMLookupListBusinessObject()
        {
            return new DMLookupListBusinessObject
                       {
                           BusinessObjectLookupListID = Guid.NewGuid(),
                           ClassID = Guid.NewGuid(),
                           AssemblyName = "stdAssemblyName",
                           Criteria = "stdCriteria",
                           ClassName = "stdClassName",
                           Timeout = new int(),
                           DMSortOrderID = Guid.NewGuid(),
                           LookupListID = Guid.NewGuid(),
                           Generated = true
                       };
        }
    }

    
    [TestFixture]
    public class TestDMSortOrderFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMSortOrder();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMSortOrder.fstart";
        }

        private static DMSortOrder CreateStandardDMSortOrder()
        {
            DMSortOrder dmSortOrder = GetStandardDMSortOrder();
            dmSortOrder.Save();
            return dmSortOrder;
        }

        private static DMSortOrder GetStandardDMSortOrder()
        {
            return new DMSortOrder
                       {
                           DMSortOrderID = Guid.NewGuid(),
                       };
        }
    }
    
    [TestFixture]
    public class TestDMSortPropertyFsStartLoading : TestFsStartLoadingBase
    {
 
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMSortProperty();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMSortProperty.fstart";
        }

        private static DMSortProperty CreateStandardDMSortProperty()
        {
            DMSortProperty dmSortProperty = GetStandardDMSortProperty();
            dmSortProperty.Save();
            return dmSortProperty;
        }

        private static DMSortProperty GetStandardDMSortProperty()
        {
            return new DMSortProperty
                       {
                           DMSortPropertyID = Guid.NewGuid(),
                           DMSortOrderID = Guid.NewGuid(),
                           PropertyName = "stdPropertyName",
                           SortDirection = "stdSortDirection",
                           SortPosition = new int(),
                       };
        }
    }    
    [TestFixture]
    public class TestDMLookupListDatabaseFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMLookupListDatabase();
        }

        protected override string GetFstartFileName()
        {
            return "standardDMLookupListDatabase.fstart";
        }

        private static DMLookupListDatabase CreateStandardDMLookupListDatabase()
        {
            DMLookupListDatabase dmLookupListDatabase = GetStandardDMLookupListDatabase();
            dmLookupListDatabase.Save();
            return dmLookupListDatabase;
        }

        private static DMLookupListDatabase GetStandardDMLookupListDatabase()
        {
            return new DMLookupListDatabase
                       {
                           DatabaseLookupListID = Guid.NewGuid(),
                           Sql ="stdSQL",
                           TimeOut = new int(),
                           LookupClassName = "stdLookUpClassName",
                           Assembly = "stdAssembly",
                           LimitToList = false,
                           LookupListID = Guid.NewGuid(),
                           Generated = true
                       };
        }
    }

    [TestFixture]
    public class TestUIFieldFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIField();
        }

        protected override string GetFstartFileName()
        {
            return "standardUIField.fstart";
        }

        private static UIField CreateStandardUIField()
        {
            UIField uiField = GetStandardUIField();
            uiField.Save();
            return uiField;
        }

        private static UIField GetStandardUIField()
        {
            return new UIField
                       {
                           UIControlTypeID = Guid.NewGuid(),
                           UIControlMapperTypeID = Guid.NewGuid(),
                           ShowAsCompulsory = true,
                           UIColumnLayoutID = Guid.NewGuid(),
                           Layout = "stdLayout",
                           LabelText = "stdLabelText",
                           UIPropID = Guid.NewGuid(),
                           Editable = true,
                           Generated = false,
                           Property = null,
                           PropertyName = "stdPropertyName",
                           OrdinalPosition = new int(),
                           ToolTipText = "stdToolTipText"
                       };
        }
    }

    [TestFixture]
    public class TestUIFormInfoFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIFormInfo();
        }

        protected override string GetFstartFileName()
        {
            return "standardUIFormInfo.fstart";
        }

        private static UIFormInfo CreateStandardUIFormInfo()
        {
            UIFormInfo uiFormInfo = GetStandardUIFormInfo();
            uiFormInfo.Save();
            return uiFormInfo;
        }

        private static UIFormInfo GetStandardUIFormInfo()
        {
            return new UIFormInfo
                       {
                         
                           Width = 300,
                           Height = 250,
                           Title = "stdTitle",
                           Generated = false,
                           UIViewID = Guid.NewGuid()
                       };
        }
    }

    [TestFixture]
    public class TestUIGridInfoFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIGridInfo();
        }
        protected override string GetFstartFileName()
        {
            return "standardUIGridInfo.fstart";
        }

        private static UIGridInfo CreateStandardUIGridInfo()
        {
            UIGridInfo uiGridInfo = GetStandardUIGridInfo();
            uiGridInfo.Save();
            return uiGridInfo;
        }

        private static UIGridInfo GetStandardUIGridInfo()
        {
            return new UIGridInfo
                       {
                           UIGridID = Guid.NewGuid(),
                           SortColumn = "stdSortColumn",
                           Generated = false,
                           UIViewID = Guid.NewGuid()
                       };
        }
    }

    [TestFixture]
    public class TestDMInheritanceRelationshipFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMInheritanceRelationship();
        }
        protected override string GetFstartFileName()
        {
            return "standardDMInheritanceRelationship.fstart";
        }

        private static DMInheritanceRelationship CreateStandardDMInheritanceRelationship()
        {
            DMInheritanceRelationship dmInheritanceRelationship = GetStandardDMInheritanceRelationship();
            dmInheritanceRelationship.Save();
            return dmInheritanceRelationship;
        }

        private static DMInheritanceRelationship GetStandardDMInheritanceRelationship()
        {
            return new DMInheritanceRelationship
            {
                SuperClassID = Guid.NewGuid(),
                Identity = "stdIdentity",
                Discriminator = "stdDiscriminator",
                Generated = false,
                InheritanceType = new ORMapping(),
                SubClassID = Guid.NewGuid(),
                IdentityPropertyID = Guid.NewGuid()
            };
        }
    }

    [TestFixture]
    public class TestDMLookupListFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMLookupList();
        }
        protected override string GetFstartFileName()
        {
            return "standardDMLookupList.fstart";
        }

        private static DMLookupList CreateStandardDMLookupList()
        {
            DMLookupList dmLookupList = GetStandardDMLookupList();
            dmLookupList.Save();
            return dmLookupList;
        }

        private static DMLookupList GetStandardDMLookupList()
        {
            return new DMLookupList
                       {
                           Generated = false
            };
        }
    }

    [TestFixture]
    public class TestDMPropertyFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMProperty();
        }
        protected override string GetFstartFileName()
        {
            return "standardDMProperty.fstart";
        }

        private static DMProperty CreateStandardDMProperty()
        {
            DMProperty dmProperty = GetStandardDMProperty();
            dmProperty.Save();
            return dmProperty;
        }
       
        private static DMProperty GetStandardDMProperty()
        {
            return new DMProperty
            {
                PropertyName = "stdPropertyName",
                ReadWriteRule = PropReadWriteRule.WriteNew,
                MappedDBColumnName = "stdMappedDBColumnName",
                Description = "stdDescription",
                Compulsory = true,
                AutoIncrementing = false,
                Length = new int(),
                KeepValuePrivate = false,
                DisplayName = "stdDisplayName",
                DefaultValue = "",
                ClassID = Guid.NewGuid(),
                Generated = false,
                ObjectIdentityID = Guid.NewGuid(),
                LookupListID = Guid.NewGuid(),
                PropertyID = Guid.NewGuid(),
                MappedDBColumnID = Guid.NewGuid(),
                OrdinalPosition= new int(),
                DefaultPropRuleID = Guid.NewGuid(),
                GenerateCode = true
            };
        }
    }

    [TestFixture]
    public class TestDMClassFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDMClass();
        }
        protected override string GetFstartFileName()
        {
            return "standardDMClass.fstart";
        }
        
        private static DMClass CreateStandardDMClass()
        {
            DMClass dmClass = GetStandardDMClass();
            dmClass.Save();
            return dmClass;
        }

        private static DMClass GetStandardDMClass()
        {
            return new DMClass
            {
             ClassNameBO = "stdClassName",
             MappedSchemaName = "stdMappedSchemaName",
             AssemblyID = Guid.NewGuid(),
             DisplayName = "stdDisplayName",
             Generated = false,
             MappedTableID = Guid.NewGuid(),
             ClassDescription = "stdClassDescription",
             TypeParameter = "stdTypeParameter",
             NeedsRegeneration = true,
             GenerateCode = true,
            };
        }
    }
  
    [TestFixture]
    public class TestDBDatabaseFsStartLoading : TestFsStartLoadingBase
    {
 
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardDBDatabase();
        }
        protected override string GetFstartFileName()
        {
            return "standardDBDatabase.fstart";
        }

        private static DBDatabase CreateStandardDBDatabase()
        {
            DBDatabase dbDatabase = GetStandardDBDatabase();
            dbDatabase.Save();
            return dbDatabase;
        }
        
        private static DBDatabase GetStandardDBDatabase()
        {
            return new DBDatabase
            {
              DatabaseName = "stdDatabaseName",
              Catalog = "stdCatalog",
              Schema = "stdSchema",
              PendingChangeType = ChangeType.None,
              Approved = true
            };
        }
    }


    [TestFixture]
    public class TestUIColumnLayoutFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIColumnLayout();
        }
        protected override string GetFstartFileName()
        {
            return "standardUIColumnLayout.fstart";
        }

        private static UIColumnLayout CreateStandardUIColumnLayout()
        {
            UIColumnLayout uiColumnLayout = GetStandardUIColumnLayout();
            uiColumnLayout.Save();
            return uiColumnLayout;
        }
 
        private static UIColumnLayout GetStandardUIColumnLayout()
        {
            return new UIColumnLayout
            {
            Width = new int(),
            Generated = false,
            UITabID = Guid.NewGuid(),
            OrdinalPosition = new int()
            };
        }
    }

    [TestFixture]
    public class TestUIPropFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIProp();
        }
        protected override string GetFstartFileName()
        {
            return "standardUIProp.fstart";
        }

        private static UIProp CreateStandardUIProp()
        {
            UIProp uiProp = GetStandardUIProp();
            uiProp.Save();
            return uiProp;
        }

        private static UIProp GetStandardUIProp()
        {
            return new UIProp
            {
           Editable = true,
           Generated = true,
           PropertyName = "stdPropertyName",
           OrdinalPosition = new int(),
           ToolTipText = "tdToolTipText"
            };
        }
    }


    [TestFixture]
    public class TestUIGridColumnInfoFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIGridColumnInfo();
        }
        protected override string GetFstartFileName()
        {
            return "standardUIGridColumnInfo.fstart";
        }

        private static UIGridColumnInfo CreateStandardUIGridColumnInfo()
        {
            UIGridColumnInfo uiGridColumnInfo = GetStandardUIGridColumnInfo();
            uiGridColumnInfo.Save();
            return uiGridColumnInfo;
        }

         private static UIGridColumnInfo GetStandardUIGridColumnInfo()
        {
            return new UIGridColumnInfo()
                       {
                           //Width = new int(),
                           //Heading = "stdHeading",
                           //Alignment = "stdAlignment",
                           //UIGridID = Guid.NewGuid(),
                           //UIPropID = Guid.NewGuid(),
                           //Editable = true,
                           //Generated = false,
                           //PropertyName= "stdPropertyName",
                           //OrdinalPosition = new int(),
                           //ToolTipText = "stdToolTipText"                      
            };
        }
    }

    [TestFixture]
    public class TestUIGridFilterFsStartLoading : TestFsStartLoadingBase
    {
  
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIGridFilter();
        }
        protected override string GetFstartFileName()
        {
            return "standardUIGridFilter.fstart";
        }

        private static UIGridFilter CreateStandardUIGridFilter()
        {
            UIGridFilter uiGridFilter = GetStandardUIGridFilter();
            uiGridFilter.Save();
            return uiGridFilter;
        }
       
        private static UIGridFilter GetStandardUIGridFilter()
        {
            return new UIGridFilter
            {
            UIGridID = Guid.NewGuid(),
            Generated = false,
            FilterMode = FilterModes.Search,
            Columns = 0
            };
        }
    }

    [TestFixture]
    public class TestUIGridFilterPropFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIGridFilterProp();
        }
        protected override string GetFstartFileName()
        {
            return "standardUIGridFilterProp.fstart";
        }
        private static UIGridFilterProp CreateStandardUIGridFilterProp()
        {
            UIGridFilterProp uiGridFilterProp = GetStandardUIGridFilterProp();
            uiGridFilterProp.Save();
            return uiGridFilterProp;
        }        
        private static UIGridFilterProp GetStandardUIGridFilterProp()
        {
            return new UIGridFilterProp
            {
             FilterControlTypeID = Guid.NewGuid(),
             DefaultValue = "stdDefaultValue",
             Nullable = true,
             FilterClauseOp = FilterClauseOperator.OpLike,
             LabelText = "stdLabelText",
             UIPropID = Guid.NewGuid(),
             Editable = true,
             Generated = false,
             PropertyName ="stdPropertyName",
             OrdinalPosition = new int(),
             ToolTipText = ""
                        };
        }
    }

    [TestFixture]
    public class TestUIParameterFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIParameter();
        }
        protected override string GetFstartFileName()
        {
            return "standardUIParameter.fstart";
        }
        private static UIParameter CreateStandardUIParameter()
        {
            UIParameter uiParameter = GetStandardUIParameter();
            uiParameter.Save();
            return uiParameter;
        }
        private static UIParameter GetStandardUIParameter()
        {
            return new UIParameter
            {
             Name = "stdName",
             Value = "stdValue",
             Generated=false,
             UIPropID = Guid.NewGuid()
            };
        }
    }

    [TestFixture]
    public class TestUITabFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUITab();
        }
        protected override string GetFstartFileName()
        {
            return "standardUITab.fstart";
        }
        private static UITab CreateStandardUITab()
        {
            UITab uiTab = GetStandardUITab();
            uiTab.Save();
            return uiTab;
        }
        private static UITab GetStandardUITab()
        {
            return new UITab
            {
            Name = "stdName",
            Generated=false,
            UIFormID = Guid.NewGuid(),
            OrdinalPosition = new int()
            };
        }
    }

    [TestFixture]
    public class TestUIViewFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardUIView();
        }
        protected override string GetFstartFileName()
        {
            return "standardUIView.fstart";
        }
        private static UIView CreateStandardUIView()
        {
            UIView uiView = GetStandardUIView();
            uiView.Save();
            return uiView;
        }
        private static UIView GetStandardUIView()
        {
            return new UIView
            {
                ViewName = "stdViewName",
                Generated = false,
                ClassID = Guid.NewGuid()
            };
        }
    }

    [TestFixture]
    public class TestGenerationSettingsFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardGenerationSettings();
        }
        protected override string GetFstartFileName()
        {
            return "standardGenerationSettings.fstart";
        }

        private static GenerationSettings CreateStandardGenerationSettings()
        {
            GenerationSettings generationSettings = GetStandardGenerationSettings();
            generationSettings.Save();
            return generationSettings;
        }

        private static GenerationSettings GetStandardGenerationSettings()
        {
            return new GenerationSettings
            {
                SolutionID = Guid.NewGuid(),
                DatabaseConnectionID = Guid.NewGuid(),
                SolutionDirectory = "stdSolutionDirectory",
                HabaneroDllPath = "stdHabaneroDllPath",
                SolutionTypeID = Guid.NewGuid(),
                CodeTemplateLibraryID = Guid.NewGuid(),
                CodeTemplateLibraryName = CodeTemplateEnum.CSharpVisualStudio2008
            };
        }

    }

    [TestFixture]
    public class TestModelModificationFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardGenerationSettings();
        }
        protected override string GetFstartFileName()
        {
            return "standardModelModification.fstart";
        }

        private static ModelModification CreateStandardGenerationSettings()
        {
            ModelModification modelModification = GetStandardGenerationSettings();
            modelModification.Save();
            return modelModification;
        }

        private static ModelModification GetStandardGenerationSettings()
        {
            return new ModelModification
            {
                Description = "stdDescription",
                ReverseEngineeringID = Guid.NewGuid(),
                Approved = true
            };
        } 
    }

    [TestFixture]
    public class TestProjectTypeFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardProjectType();
        }
        protected override string GetFstartFileName()
        {
            return "standardProjectType.fstart";
        }

        private static ProjectType CreateStandardProjectType()
        {
            ProjectType projectType = GetStandardProjectType();
            projectType.Save();
            return projectType;
        }

        private static ProjectType GetStandardProjectType()
        {
            return new ProjectType
            {
                Name = "stdName"
            };
        }

    }

    [TestFixture]
    public class TestProjectTypeGenerationFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardProjectTypeGeneration();
        }
        protected override string GetFstartFileName()
        {
            return "standardProjectTypeGeneration.fstart";
        }

        private static ProjectTypeGeneration CreateStandardProjectTypeGeneration()
        {
            ProjectTypeGeneration projectTypeGeneration = GetStandardProjectTypeGeneration();
            projectTypeGeneration.Save();
            return projectTypeGeneration;
        }

        private static ProjectTypeGeneration GetStandardProjectTypeGeneration()
        {
            return new ProjectTypeGeneration
            {
                GenerationSettingsID = Guid.NewGuid(),
                ProjectTypeID = Guid.NewGuid(),
                ProjectName = "stdProjectName",
                ToBeGenerated = true
            };
        }
    }

    [TestFixture]
    public class TestTypeMappingFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardTypeMapping();
        }
        protected override string GetFstartFileName()
        {
            return "standardTypeMapping.fstart";
        }
        private static TypeMapping CreateStandardTypeMapping()
        {
            TypeMapping typeMapping = GetStandardTypeMapping();
            typeMapping.Save();
            return typeMapping;
        }
        private static TypeMapping GetStandardTypeMapping()
        {
            return new TypeMapping
            {
                FromType = "stdFromType",
                ToType = "stdToType",
            };
        }
    }

    [TestFixture]
    public class TestReverseEngineeringSettingsFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardReverseEngineeringSettings();
        }
        protected override string GetFstartFileName()
        {
            return "standardReverseEngineeringSettings.fstart";
        }
        private static ReverseEngineeringSettings CreateStandardReverseEngineeringSettings()
        {
            ReverseEngineeringSettings reverseEngineeringSettings = GetStandardReverseEngineeringSettings();
            reverseEngineeringSettings.Save();
            return reverseEngineeringSettings;
        }
        private static ReverseEngineeringSettings GetStandardReverseEngineeringSettings()
        {
            return new ReverseEngineeringSettings()
            {
                ImportTables = true,
                ImportViews = true,
                TableNameFilter = "stdTableNameFilter",
                TableSchemaFilter = "stdTableSchemaFilter",
                ViewNameFilter = "stdViewNameFilter",
                ViewSchemaFilter = "stdViewSchemaFilter"
            };
        }
    }
    [TestFixture]
    public class TestSolutionTypeFsStartLoading : TestFsStartLoadingBase
    {
        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardSolutionType();
        }
        protected override string GetFstartFileName()
        {
            return "standardSolutionType.fstart";
        }
        private static SolutionType CreateStandardSolutionType()
        {
            SolutionType solutionType = GetStandardSolutionType();
            solutionType.Save();
            return solutionType;
        }
        private static SolutionType GetStandardSolutionType()
        {
            return new SolutionType()
            {
                Name = "stdName"
            };
        }
    }

    [TestFixture]
    public class TestSolutionTypeProjectFsStartLoading : TestFsStartLoadingBase
    {

        protected override IMergableBo GetStandardMergableBO()
        {
            return CreateStandardSolutionTypeProject();
        }
        protected override string GetFstartFileName()
        {
            return "standardSolutionTypeProject.fstart";
        }
        private static SolutionTypeProject CreateStandardSolutionTypeProject()
        {
            SolutionTypeProject solutionTypeProject = GetStandardSolutionTypeProject();
            solutionTypeProject.Save();
            return solutionTypeProject;
        }
        private static SolutionTypeProject GetStandardSolutionTypeProject()
        {
            return new SolutionTypeProject()
            {
                SolutionTypeID = Guid.NewGuid(),
                ProjectTypeID = Guid.NewGuid()
            };
        }
    }
}